package com.zrh.jsd.service.studydemo.threadpool;

import java.util.concurrent.*;

public class FutureTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService cachePool = Executors.newCachedThreadPool();
        Future<Integer> future = cachePool.submit(() -> {
            System.out.println("异步任务开始==11==start====");
            TimeUnit.SECONDS.sleep(10);
            System.out.println("异步任务结束==11==end====");
            return 10;
        });
        Future<Integer> future1 = cachePool.submit(() -> {
            System.out.println("异步任务开始==22==start====");
            TimeUnit.SECONDS.sleep(3);
            System.out.println("异步任务结束==22==end====");
            return 3;
        });
        // 提交了一步任务后，主线程可以继续干一些其他的事情
        doSomeThinsElese();

        // get 方式会导致当前线程阻塞，，这显然违背了异步计算的初衷
        //为了获取异步计算结果，我们可以通过furure.get来获取
       /* int result, result2;
        result = future.get();
        result2 = future1.get();
        System.out.println("zzzzzzzzzzzz=====" + result);
        System.out.println("zzzzzzzzzzzz=====" + result2);*/

        // 轮询方式显然不会导致当前的线程阻塞，但会导致高频的CPU负载
        while (true) {
            if (future.isDone()){
                System.out.println(future.get());
                break;
            }
            if (future1.isDone()){
                System.out.println(future1.get());
                break;
            }
        }

    }

    private static void doSomeThinsElese() throws InterruptedException {
        System.out.println("主线任务开始==doSomeThinsElese===start=");
        TimeUnit.SECONDS.sleep(3);
        System.out.println("主线任务结束==doSomeThinsElese===end=接下来获取异步计算的结果去干剩下的事情=");
    }
}
